home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / mozilla-firefox / include / libreg / NSReg.h next >
C/C++ Source or Header  |  2006-05-08  |  22KB  |  592 lines
  1. /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * ***** BEGIN LICENSE BLOCK *****
  4.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  5.  *
  6.  * The contents of this file are subject to the Mozilla Public License Version
  7.  * 1.1 (the "License"); you may not use this file except in compliance with
  8.  * the License. You may obtain a copy of the License at
  9.  * http://www.mozilla.org/MPL/
  10.  *
  11.  * Software distributed under the License is distributed on an "AS IS" basis,
  12.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13.  * for the specific language governing rights and limitations under the
  14.  * License.
  15.  *
  16.  * The Original Code is Mozilla Communicator client code, released
  17.  * March 31, 1998.
  18.  *
  19.  * The Initial Developer of the Original Code is
  20.  * Netscape Communications Corporation.
  21.  * Portions created by the Initial Developer are Copyright (C) 1998
  22.  * the Initial Developer. All Rights Reserved.
  23.  *
  24.  * Contributor(s):
  25.  *   Daniel Veditz <dveditz@netscape.com>
  26.  *
  27.  * Alternatively, the contents of this file may be used under the terms of
  28.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  29.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30.  * in which case the provisions of the GPL or the LGPL are applicable instead
  31.  * of those above. If you wish to allow use of your version of this file only
  32.  * under the terms of either the GPL or the LGPL, and not to allow others to
  33.  * use your version of this file under the terms of the MPL, indicate your
  34.  * decision by deleting the provisions above and replace them with the notice
  35.  * and other provisions required by the GPL or the LGPL. If you do not delete
  36.  * the provisions above, a recipient may use your version of this file under
  37.  * the terms of any one of the MPL, the GPL or the LGPL.
  38.  *
  39.  * ***** END LICENSE BLOCK ***** */
  40. /* NSReg.h
  41.  */
  42. #ifndef _NSREG_H_
  43. #define _NSREG_H_
  44.  
  45. typedef void (*nr_RegPackCallbackFunc) (void *userData, int32 bytes, int32 totalBytes);
  46.  
  47. typedef int32   REGERR;
  48. typedef int32   RKEY;
  49. typedef uint32  REGENUM;
  50. typedef void *  HREG;
  51.  
  52. typedef struct _reginfo
  53. {
  54.    uint16  size;        /* must be initialized to sizeof(REGINFO) */
  55.    uint16  entryType;
  56.    uint32  entryLength;
  57. } REGINFO;
  58.  
  59. #define REGERR_OK           (0)
  60. #define REGERR_FAIL         (1)
  61. #define REGERR_NOMORE       (2)
  62. #define REGERR_NOFIND       (3)
  63. #define REGERR_BADREAD      (4)
  64. #define REGERR_BADLOCN      (5)
  65. #define REGERR_PARAM        (6)
  66. #define REGERR_BADMAGIC     (7)
  67. #define REGERR_BADCHECK     (8)
  68. #define REGERR_NOFILE       (9)
  69. #define REGERR_MEMORY       (10)
  70. #define REGERR_BUFTOOSMALL  (11)
  71. #define REGERR_NAMETOOLONG  (12)
  72. #define REGERR_REGVERSION   (13)
  73. #define REGERR_DELETED      (14)
  74. #define REGERR_BADTYPE      (15)
  75. #define REGERR_NOPATH       (16)
  76. #define REGERR_BADNAME      (17)
  77. #define REGERR_READONLY     (18)
  78. #define REGERR_BADUTF8      (19)
  79.  
  80.  
  81. /* Total path length */
  82. #define MAXREGPATHLEN   (2048)
  83. /* Name on the path (including null terminator) */
  84. #define MAXREGNAMELEN   (512)
  85. /* Value of an entry */
  86. #define MAXREGVALUELEN  (0x7FFF)
  87.  
  88. /* Standard keys */
  89. #define ROOTKEY_USERS                   (0x01)
  90. #define ROOTKEY_COMMON                  (0x02)
  91. #define ROOTKEY_CURRENT_USER            (0x03)
  92. #define ROOTKEY_PRIVATE                 (0x04)
  93.  
  94. /* enumeration styles */
  95. #define REGENUM_NORMAL                  (0x00)
  96. #define REGENUM_CHILDREN                REGENUM_NORMAL
  97. #define REGENUM_DESCEND                 (0x01)
  98. #define REGENUM_DEPTH_FIRST             (0x02)
  99.  
  100. /* entry data types */
  101. #define REGTYPE_ENTRY                 (0x0010)
  102. #define REGTYPE_ENTRY_STRING_UTF      (REGTYPE_ENTRY + 1)
  103. #define REGTYPE_ENTRY_INT32_ARRAY     (REGTYPE_ENTRY + 2)
  104. #define REGTYPE_ENTRY_BYTES           (REGTYPE_ENTRY + 3)
  105. #define REGTYPE_ENTRY_FILE            (REGTYPE_ENTRY + 4)
  106.  
  107. #define REG_DELETE_LIST_KEY  "Mozilla/XPInstall/Delete List"
  108. #define REG_REPLACE_LIST_KEY "Mozilla/XPInstall/Replace List"
  109. #define REG_UNINSTALL_DIR    "Mozilla/XPInstall/Uninstall/"
  110. #define REG_REPLACE_SRCFILE  "ReplacementFile"
  111. #define REG_REPLACE_DESTFILE "DestinationFile"
  112.  
  113. #define UNINSTALL_NAV_STR "_"
  114.  
  115.  
  116. #define UNIX_GLOBAL_FLAG     "MOZILLA_SHARED_REGISTRY"
  117.  
  118. /* Platform-dependent declspec for library interface */
  119. #if defined(XP_WIN)
  120.   #if defined(WIN32)
  121.     #if defined (STANDALONE_REGISTRY)
  122.        #define VR_INTERFACE(type)     __declspec(dllexport) type __cdecl
  123.     #else
  124.        #define VR_INTERFACE(type)     __declspec(dllexport) type __stdcall
  125.     #endif
  126.  
  127.   #else
  128.   #define VR_INTERFACE(type)     type _far _pascal _export
  129.   #endif
  130. #elif defined XP_MAC
  131.   #define VR_INTERFACE(__x)  __declspec(export) __x
  132. #elif defined (HAVE_VISIBILITY_ATTRIBUTE)
  133.   #define VR_INTERFACE(type)     __attribute__ ((visibility ("default"))) type
  134. #else
  135.   #define VR_INTERFACE(type)     type
  136. #endif
  137.  
  138. PR_BEGIN_EXTERN_C
  139.  
  140.  
  141.  
  142. /* ---------------------------------------------------------------------
  143.  * Registry API -- General
  144.  * ---------------------------------------------------------------------
  145.  */
  146.  
  147.  
  148. /* ---------------------------------------------------------------------
  149.  * NR_RegSetBufferSize - Sets the file buffer size
  150.  *
  151.  * Parameters:
  152.  *    hReg       - handle to opened registry
  153.  *    bufsize    - size of the new buffer
  154.  *
  155.  * Output:
  156.  * ---------------------------------------------------------------------
  157.  *    returns the size of the buffer or -1 for err
  158.  */
  159. VR_INTERFACE(int) NR_RegSetBufferSize(
  160.          HREG hReg,        /* handle to opened registry */
  161.          int  bufsize
  162.        );
  163.  
  164.  
  165. /* ---------------------------------------------------------------------
  166.  * NR_RegOpen - Open a netscape XP registry
  167.  *
  168.  * Parameters:
  169.  *    filename   - registry file to open. NULL or ""  opens the standard
  170.  *                 local registry.
  171.  *    hReg       - OUT: handle to opened registry
  172.  *
  173.  * Output:
  174.  * ---------------------------------------------------------------------
  175.  */
  176. VR_INTERFACE(REGERR) NR_RegOpen(
  177.          const char *filename, /* reg. file to open (NULL == standard registry) */
  178.          HREG *hReg            /* OUT: handle to opened registry */
  179.        );
  180.  
  181.  
  182. /* ---------------------------------------------------------------------
  183.  * NR_RegClose - Close a netscape XP registry
  184.  *
  185.  * Parameters:
  186.  *    hReg     - handle of open registry to be closed.
  187.  *
  188.  * After calling this routine the handle is no longer valid
  189.  * ---------------------------------------------------------------------
  190.  */
  191. VR_INTERFACE(REGERR) NR_RegClose(
  192.          HREG hReg         /* handle of open registry to close */
  193.        );
  194.  
  195.  
  196. /* ---------------------------------------------------------------------
  197.  * NR_RegFlush - Manually flush data in a netscape XP registry
  198.  *
  199.  * Parameters:
  200.  *    hReg     - handle of open registry to be flushed.
  201.  *
  202.  * ---------------------------------------------------------------------
  203.  */
  204. VR_INTERFACE(REGERR) NR_RegFlush(
  205.          HREG hReg         /* handle of open registry to flush */
  206.        );
  207.  
  208.  
  209. /* ---------------------------------------------------------------------
  210.  * NR_RegIsWritable - Check read/write status of open registry
  211.  *
  212.  * Parameters:
  213.  *    hReg     - handle of open registry to query
  214.  * Returns:
  215.  *    REGERR_OK if writable, REGERR_READONLY if not, possibly
  216.  *    other errors for an invalid hReg
  217.  * ---------------------------------------------------------------------
  218.  */
  219. VR_INTERFACE(REGERR) NR_RegIsWritable(
  220.          HREG hReg         /* handle of open registry to query */
  221.        );
  222.  
  223. VR_INTERFACE(REGERR) NR_RegPack(
  224.          HREG hReg,         /* handle of open registry to pack */
  225.          void *userData,
  226.          nr_RegPackCallbackFunc fn
  227.        );
  228.  
  229.  
  230. /* ---------------------------------------------------------------------
  231.  * NR_RegSetUsername - Set the current username
  232.  * 
  233.  * If the current user profile name is not set then trying to use
  234.  * HKEY_CURRENT_USER will result in an error.
  235.  *
  236.  * Parameters:
  237.  *     name     - name of the current user
  238.  *
  239.  * Output:
  240.  * ---------------------------------------------------------------------
  241.  */
  242. VR_INTERFACE(REGERR) NR_RegSetUsername(
  243.          const char *name  /* name of current user */
  244.        );
  245.  
  246.  
  247. /* ---------------------------------------------------------------------
  248.  * NR_RegGetUniqueName
  249.  * 
  250.  * Returns a unique name that can be used for anonymous key/value names
  251.  *
  252.  * Parameters:
  253.  *     hReg     - handle of open registry
  254.  *     outbuf   - where to put the string
  255.  *     buflen   - how big the buffer is
  256.  * ---------------------------------------------------------------------
  257.  */
  258. VR_INTERFACE(REGERR) NR_RegGetUniqueName(
  259.          HREG hReg,     /* handle of open registry */
  260.          char* outbuf,  /* buffer to hold key name */
  261.          uint32 buflen  /* size of buffer */
  262.        );
  263.  
  264.  
  265. /* ---------------------------------------------------------------------
  266.  * DO NOT USE -- Will be removed 
  267.  * ---------------------------------------------------------------------
  268.  */
  269. VR_INTERFACE(REGERR) NR_RegGetUsername(
  270.          char **name        /* on return, an alloc'ed copy of the current user name */
  271.        );
  272.  
  273.  
  274.  
  275.  
  276.  
  277.  
  278. /* ---------------------------------------------------------------------
  279.  * Registry API -- Key Management functions
  280.  * ---------------------------------------------------------------------
  281.  */
  282.  
  283. /* ---------------------------------------------------------------------
  284.  * NR_RegAddKey - Add a key node to the registry
  285.  *
  286.  * Can also be used to find an existing node for convenience.
  287.  *
  288.  * Parameters:
  289.  *    hReg     - handle of open registry
  290.  *    key      - registry key obtained from NR_RegGetKey(),
  291.  *               or one of the standard top-level keys
  292.  *    path     - relative path of key to be added.  Intermediate
  293.  *               nodes will be added if necessary.
  294.  *    newkey   - If not null returns RKEY of new or found node
  295.  * ---------------------------------------------------------------------
  296.  */
  297. VR_INTERFACE(REGERR) NR_RegAddKey(
  298.          HREG hReg,        /* handle of open registry */
  299.          RKEY key,         /* root key */
  300.          char *path,       /* relative path of subkey to add */
  301.          RKEY *newKey      /* if not null returns newly created key */
  302.        );
  303.  
  304.  
  305. /* ---------------------------------------------------------------------
  306.  * NR_RegAddKeyRaw - Add a key node to the registry
  307.  *
  308.  *      This routine is different from NR_RegAddKey() in that it takes 
  309.  *      a keyname rather than a path.
  310.  *
  311.  * Parameters:
  312.  *    hReg     - handle of open registry
  313.  *    key      - registry key obtained from NR_RegGetKey(),
  314.  *               or one of the standard top-level keys
  315.  *    keyname  - name of key to be added. No parsing of this
  316.  *               name happens.
  317.  *    newkey   - if not null the RKEY of the new key is returned
  318.  * ---------------------------------------------------------------------
  319.  */
  320. VR_INTERFACE(REGERR) NR_RegAddKeyRaw(
  321.          HREG hReg,        /* handle of open registry */
  322.          RKEY key,         /* root key */
  323.          char *keyname,    /* name of key to add */
  324.          RKEY *newKey      /* if not null returns newly created key */
  325.        );
  326.  
  327.  
  328. /* ---------------------------------------------------------------------
  329.  * NR_RegDeleteKey - Delete the specified key
  330.  *
  331.  * Note that delete simply orphans blocks and makes no attempt
  332.  * to reclaim space in the file. Use NR_RegPack()
  333.  *
  334.  * Cannot be used to delete keys with child keys
  335.  *
  336.  * Parameters:
  337.  *    hReg     - handle of open registry
  338.  *    key      - starting node RKEY, typically one of the standard ones.
  339.  *    path     - relative path of key to delete
  340.  * ---------------------------------------------------------------------
  341.  */
  342. VR_INTERFACE(REGERR) NR_RegDeleteKey(
  343.          HREG hReg,        /* handle of open registry */
  344.          RKEY key,         /* root key */
  345.          char *path        /* relative path of subkey to delete */
  346.        );
  347.  
  348.  
  349. /* ---------------------------------------------------------------------
  350.  * NR_RegDeleteKeyRaw - Delete the specified raw key
  351.  *
  352.  * Note that delete simply orphans blocks and makes no attempt
  353.  * to reclaim space in the file. Use NR_RegPack()
  354.  *
  355.  * Parameters:
  356.  *    hReg     - handle of open registry
  357.  *    key      - RKEY or parent to the raw key you wish to delete
  358.  *    keyname  - name of child key to delete
  359.  * ---------------------------------------------------------------------
  360.  */
  361. VR_INTERFACE(REGERR) NR_RegDeleteKeyRaw(
  362.          HREG hReg,        /* handle of open registry */
  363.          RKEY key,         /* root key */
  364.          char *keyname     /* name subkey to delete */
  365.        );
  366.  
  367.  
  368. /* ---------------------------------------------------------------------
  369.  * NR_RegGetKey - Get the RKEY value of a node from its path
  370.  *
  371.  * Parameters:
  372.  *    hReg     - handle of open registry
  373.  *    key      - starting node RKEY, typically one of the standard ones.
  374.  *    path     - relative path of key to find.  (a blank path just gives you
  375.  *               the starting key--useful for verification, VersionRegistry)
  376.  *    result   - if successful the RKEY of the specified sub-key
  377.  * ---------------------------------------------------------------------
  378.  */
  379. VR_INTERFACE(REGERR) NR_RegGetKey(
  380.          HREG hReg,        /* handle of open registry */
  381.          RKEY key,         /* root key */
  382.          const char *path, /* relative path of subkey to find */
  383.          RKEY *result      /* returns RKEY of specified sub-key */
  384.        );
  385.  
  386.  
  387. /* ---------------------------------------------------------------------
  388.  * NR_RegGetKeyRaw - Get the RKEY value of a node from its keyname
  389.  *
  390.  * Parameters:
  391.  *    hReg     - handle of open registry
  392.  *    key      - starting node RKEY, typically one of the standard ones.
  393.  *    keyname  - keyname of key to find.  (a blank keyname just gives you
  394.  *               the starting key--useful for verification, VersionRegistry)
  395.  *    result   - if successful the RKEY of the specified sub-key
  396.  * ---------------------------------------------------------------------
  397.  */
  398. VR_INTERFACE(REGERR) NR_RegGetKeyRaw(
  399.          HREG hReg,        /* handle of open registry */
  400.          RKEY key,         /* root key */
  401.          char *keyname,       /* name of key to get */
  402.          RKEY *result      /* returns RKEY of specified sub-key */
  403.        );
  404.  
  405.  
  406. /* ---------------------------------------------------------------------
  407.  * NR_RegEnumSubkeys - Enumerate the subkey names for the specified key
  408.  *
  409.  * Returns REGERR_NOMORE at end of enumeration.
  410.  *
  411.  * Parameters:
  412.  *    hReg     - handle of open registry
  413.  *    key      - RKEY of key to enumerate--obtain with NR_RegGetKey()
  414.  *    eState   - enumerations state, must contain NULL to start
  415.  *    buffer   - location to store subkey names.  Once an enumeration
  416.  *               is started user must not modify contents since values
  417.  *               are built using the previous contents.
  418.  *    bufsize  - size of buffer for names
  419.  *    style    - 0 returns direct child keys only, REGENUM_DESCEND
  420.  *               returns entire sub-tree
  421.  * ---------------------------------------------------------------------
  422.  */
  423. VR_INTERFACE(REGERR) NR_RegEnumSubkeys(
  424.          HREG    hReg,        /* handle of open registry */
  425.          RKEY    key,         /* containing key */
  426.          REGENUM *state,      /* enum state, must be NULL to start */
  427.          char    *buffer,     /* buffer for entry names */
  428.          uint32  bufsize,     /* size of buffer */
  429.          uint32  style        /* 0: children only; REGENUM_DESCEND: sub-tree */
  430.        );
  431.  
  432.  
  433.  
  434. /* ---------------------------------------------------------------------
  435.  * Registry API -- Entry Management functions
  436.  * ---------------------------------------------------------------------
  437.  */
  438.  
  439.  
  440. /* ---------------------------------------------------------------------
  441.  * NR_RegGetEntryInfo - Get some basic info about the entry data
  442.  *
  443.  * Parameters:
  444.  *    hReg     - handle of open registry
  445.  *    key      - RKEY of key that contains entry--obtain with NR_RegGetKey()
  446.  *    name     - name of entry
  447.  *    info     - return: Entry info object
  448.  * ---------------------------------------------------------------------
  449.  */
  450. VR_INTERFACE(REGERR) NR_RegGetEntryInfo(
  451.          HREG    hReg,     /* handle of open registry */
  452.          RKEY    key,      /* containing key */
  453.          char    *name,    /* entry name */
  454.          REGINFO *info     /* returned entry info */
  455.        );
  456.  
  457.        
  458. /* ---------------------------------------------------------------------
  459.  * NR_RegGetEntryString - Get the UTF string value associated with the
  460.  *                       named entry of the specified key.
  461.  *
  462.  * Parameters:
  463.  *    hReg     - handle of open registry
  464.  *    key      - RKEY of key that contains entry--obtain with NR_RegGetKey()
  465.  *    name     - name of entry
  466.  *    buffer   - destination for string
  467.  *    bufsize  - size of buffer
  468.  * ---------------------------------------------------------------------
  469.  */
  470. VR_INTERFACE(REGERR) NR_RegGetEntryString(
  471.          HREG   hReg,      /* handle of open registry */
  472.          RKEY   key,       /* containing key */
  473.          char   *name,     /* entry name */
  474.          char   *buffer,   /* buffer to hold value (UTF String) */
  475.          uint32 bufsize    /* length of buffer */
  476.        );
  477.  
  478. /* ---------------------------------------------------------------------
  479.  * NR_RegGetEntry - Get the value data associated with the
  480.  *                  named entry of the specified key.
  481.  *
  482.  * Parameters:
  483.  *    hReg     - handle of open registry
  484.  *    key      - RKEY of key that contains entry--obtain with NR_RegGetKey()
  485.  *    name     - name of entry
  486.  *    buffer   - destination for data
  487.  *    size     - in:  size of buffer
  488.  *               out: size of actual data (incl. \0 term. for strings)
  489.  * ---------------------------------------------------------------------
  490.  */
  491. VR_INTERFACE(REGERR) NR_RegGetEntry(
  492.          HREG   hReg,      /* handle of open registry */
  493.          RKEY   key,       /* containing key */
  494.          char   *name,     /* entry name */
  495.          void   *buffer,   /* buffer to hold value */
  496.          uint32 *size      /* in:length of buffer */
  497.        );                  /* out: data length, >>includes<< null terminator*/
  498.  
  499.  
  500. /* ---------------------------------------------------------------------
  501.  * NR_RegSetEntryString - Store a UTF-8 string value associated with the
  502.  *                       named entry of the specified key.  Used for
  503.  *                       both creation and update.
  504.  *
  505.  * Parameters:
  506.  *    hReg     - handle of open registry
  507.  *    key      - RKEY of key that contains entry--obtain with NR_RegGetKey()
  508.  *    name     - name of entry
  509.  *    buffer   - UTF-8 String to store
  510.  * ---------------------------------------------------------------------
  511.  */
  512. VR_INTERFACE(REGERR) NR_RegSetEntryString(
  513.          HREG hReg,        /* handle of open registry */
  514.          RKEY key,         /* containing key */
  515.          char *name,       /* entry name */
  516.          char *buffer      /* UTF String value */
  517.        );
  518.  
  519.  
  520. /* ---------------------------------------------------------------------
  521.  * NR_RegSetEntry - Store value data associated with the named entry
  522.  *                  of the specified key.  Used for both creation and update.
  523.  *
  524.  * Parameters:
  525.  *    hReg     - handle of open registry
  526.  *    key      - RKEY of key that contains entry--obtain with NR_RegGetKey()
  527.  *    name     - name of entry
  528.  *    type     - type of data to be stored
  529.  *    buffer   - data to store
  530.  *    size     - length of data to store in bytes
  531.  * ---------------------------------------------------------------------
  532.  */
  533. VR_INTERFACE(REGERR) NR_RegSetEntry(
  534.          HREG   hReg,        /* handle of open registry */
  535.          RKEY   key,         /* containing key */
  536.          char   *name,       /* entry name */
  537.          uint16 type,        /* type of value data */
  538.          void   *buffer,     /* data buffer */
  539.          uint32 size         /* data length in bytes; incl. null term for strings */
  540.        );
  541.  
  542.  
  543. /* ---------------------------------------------------------------------
  544.  * NR_RegDeleteEntry - Delete the named entry
  545.  *
  546.  * Parameters:
  547.  *    hReg     - handle of open registry
  548.  *    key      - RKEY of key that contains entry--obtain with NR_RegGetKey()
  549.  *    name     - name of entry
  550.  * ---------------------------------------------------------------------
  551.  */
  552. VR_INTERFACE(REGERR) NR_RegDeleteEntry(
  553.          HREG hReg,        /* handle of open registry */
  554.          RKEY key,         /* containing key */
  555.          char *name        /* value name */
  556.        );
  557.  
  558.  
  559. /* ---------------------------------------------------------------------
  560.  * NR_RegEnumEntries - Enumerate the entry names for the specified key
  561.  *
  562.  * Returns REGERR_NOMORE at end of enumeration.
  563.  *
  564.  * Parameters:
  565.  *    hReg     - handle of open registry
  566.  *    key      - RKEY of key that contains entry--obtain with NR_RegGetKey()
  567.  *    eState   - enumerations state, must contain NULL to start
  568.  *    buffer   - location to store entry names
  569.  *    bufsize  - size of buffer for names
  570.  * ---------------------------------------------------------------------
  571.  */
  572. VR_INTERFACE(REGERR) NR_RegEnumEntries(
  573.          HREG    hReg,        /* handle of open registry */
  574.          RKEY    key,         /* containing key */
  575.          REGENUM *state,      /* enum state, must be NULL to start */
  576.          char    *buffer,     /* buffer for entry names */
  577.          uint32  bufsize,     /* size of buffer */
  578.          REGINFO *info        /* optional; returns info about entry */
  579.        );
  580.  
  581.  
  582. VR_INTERFACE(void)      NR_ShutdownRegistry(void);
  583. VR_INTERFACE(REGERR)    NR_StartupRegistry(void);
  584.  
  585.  
  586. PR_END_EXTERN_C
  587.  
  588. #endif   /* _NSREG_H_ */
  589.  
  590. /* EOF: NSReg.h */
  591.  
  592.